//ICCx01 by BR - INICIO - Inclusão da Classe Canal
package jEDF.Hypnogram;
import jEDF.EDF.*;
import java.io.*;

public class Canal {

    private double m_FFT[][];
    private double m_maior[];
    private double m_sampling;
    private short m_data[];
    private double m_ganho = 0; //ganho do conversor A/D

    public Canal() {
        m_FFT = null;
        m_data = null;
        m_sampling = 0;
        m_ganho = 0;
    }

    public Canal(EDFSignal signal) {

        //extraindo FFT deste canal
        signal.fftToText1Hz(new File("FFTsignal.txt"), 0, signal.getEdfFile().getNbRecords(), 30);

        setFFT(signal.getFftSignal()); //FFT do primeiro canal frontal - linha = época de 30s, coluna = raia de 1Hz a partir de 0Hz até 32Hz
        setData(signal.getSelectedSignalData(0, signal.getEdfFile().getTotalDuration(), 0, 1));
        setSampling(signal.getSamplingRate());
        setGanho((signal.getPhysMax() - signal.getPhysMin()) / (signal.getDigMax() - signal.getDigMin()));
    }

    public double getGanho() {
        return m_ganho;
    }

    public void setGanho(double m_ganho) {
        this.m_ganho = m_ganho;
    }

    public double[][] getFFT() {
        return m_FFT;
    }

    public short[] getData() {
        return m_data;
    }

    public short getData(int i) {
        return m_data[i];
    }

    public double[] getMaior() {
        return m_maior;
    }

    public double getMaiorFreqFFT(int epoca) {
        CalcMaiorFreqAmpl(epoca);
        return m_maior[0];
    }

    public double getMaiorAmplFFT(int epoca) {
        CalcMaiorFreqAmpl(epoca);
        return m_maior[1];
    }

    public double getSampling() {
        return m_sampling;
    }

    public void setFFT(double[][] m_FFT) {
        this.m_FFT = m_FFT;
    }

    public void setData(short[] m_data) {
        this.m_data = m_data;
    }

    public void setMaior(double[] m_maior) {
        this.m_maior = m_maior;
    }

    public void setSampling(double m_sampling) {
        this.m_sampling = m_sampling;
    }

    public void CalcMaiorFreqAmpl(int epoca) {
        int maiorFreq = 0;
        double maiorAmpl = 0;

        if (m_FFT != null) {
            //procura  qual é a maior frequencia dos canais frontais e suas amplitudes para CADA época
            for (int freq = 0; freq < 32; freq++) {
                if (m_FFT[epoca][freq] > maiorAmpl) {
                    maiorFreq = freq;
                    maiorAmpl = m_FFT[epoca][freq];
                }
            }
            m_maior = new double[2];
            m_maior[0] = maiorFreq;
            m_maior[1] = maiorAmpl;
        }
    }

    public double getMaiorAmpl(int epoca) {
        double amplitude = 0;
        int posAtual = epoca * 30;
        for (int tempo = posAtual; tempo < Math.min(posAtual + 30, m_data.length / m_sampling); tempo = tempo + 1) {
            for (int amostra = (int) (tempo * m_sampling); amostra < (int) ((tempo + 1) * m_sampling) - 1; amostra++) {
                if ((Math.abs(m_data[amostra]) * m_ganho) > amplitude) {
                    amplitude = Math.abs(m_data[amostra] * m_ganho);
                    break;
                }
            }
        }
        return amplitude;
    }

     public double getMediaAmpl(int epoca) {
        double media = 0;
        double soma = 0;
        double cont = 0;
        int posAtual = epoca * 30;
        for (int tempo = posAtual; tempo < Math.min(posAtual + 30, m_data.length / m_sampling); tempo = tempo + 1) {
            for (int amostra = (int) (tempo * m_sampling); amostra < (int) ((tempo + 1) * m_sampling) - 1; amostra++) {
                    soma = Math.abs(m_data[amostra] * m_ganho);
                    cont++;
            }
        }
        media = soma/cont;
        return media;
    }

    //Função retorna qual a porcentagem da epoca que tem amplitude maior que determinado valor
    public double PercentualAmplMaior(int epoca, int valor) {
        double cont = 0;
        int posAtual = epoca * 30;
        for (int tempo = posAtual; tempo < Math.min(posAtual + 30, m_data.length / m_sampling); tempo = tempo + 3) {
            for (int amostra = (int) (tempo * m_sampling); amostra < (int) ((tempo + 3) * m_sampling) - 1; amostra++) {
                if (m_data[amostra] * m_ganho > valor) {
                    cont += 0.1;
                    break;
                }
            }
        }

        return cont;
    }

    //Função retorna qual a porcentagem da epoca que tem amplitude menor que determinado valor
    public double PercentualAmplMenor(int epoca, int valor) {


        double cont = 0;
        final int PERIODO = 3;
        int posAtual = epoca * 30;
        for (int tempo = posAtual; tempo < Math.min(posAtual + 30, m_data.length / m_sampling); tempo = tempo + PERIODO) {
            for (int amostra = (int) (tempo * m_sampling); amostra < (int) ((tempo + PERIODO) * m_sampling) - 1; amostra++) {
                if (m_data[amostra] * m_ganho < valor) {
                    cont += (30/PERIODO)/100;
                    break;
                }
            }
        }

        return cont;
    }


//IMPFx01 by MN - INICIO - Inclusão Metodo que verifica a taxa de presença de determinado intervalo de frequencia
    public double PercentualFreq(int epoca, double min, double max) {
        double cont = 0;
        double ampl_total = 0;
        for (int freq = 0; freq <= 32; freq++) {
                 ampl_total += m_FFT[epoca][freq];
        }

        for (int freq = 0; freq <= 32; freq++) {
            if(freq >= min && freq <= max){
                    cont += (m_FFT[epoca][freq]);                
            }
        }
        cont = cont / ampl_total;
        return cont;
    }
//IMPFx01 by MN - FINAL - Inclusão Metodo que verifica a taxa de presença de determinado intervalo de frequencia
}

//ICCx01 by BR - FIM - Inclusão da Classe Canal

